/*
CryptoJS v3.1.2
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
var CryptoJS =
    CryptoJS ||
    (function (h, s) {
        const f = {}
        const g = (f.lib = {})
        const q = function () {}
        const m = (g.Base = {
            extend: function (a) {
                q.prototype = this
                const c = new q()
                a && c.mixIn(a)
                c.hasOwnProperty('init') ||
                (c.init = function () {
                    c.$super.init.apply(this, arguments)
                })
                c.init.prototype = c
                c.$super = this
                return c
            },
            create: function () {
                const a = this.extend()
                a.init.apply(a, arguments)
                return a
            },
            init: function () {},
            mixIn: function (a) {
                for (const c in a) a.hasOwnProperty(c) && (this[c] = a[c])
                a.hasOwnProperty('toString') && (this.toString = a.toString)
            },
            clone: function () {
                return this.init.prototype.extend(this)
            },
        })
        var r = (g.WordArray = m.extend({
            init: function (a, c) {
                a = this.words = a || []
                this.sigBytes = c != s ? c : 4 * a.length
            },
            toString: function (a) {
                return (a || k).stringify(this)
            },
            concat: function (a) {
                const c = this.words
                const d = a.words
                const b = this.sigBytes
                a = a.sigBytes
                this.clamp()
                if (b % 4)
                    for (var e = 0; e < a; e++)
                        c[(b + e) >>> 2] |=
                            ((d[e >>> 2] >>> (24 - 8 * (e % 4))) & 255) << (24 - 8 * ((b + e) % 4))
                else if (d.length > 65535) for (e = 0; e < a; e += 4) c[(b + e) >>> 2] = d[e >>> 2]
                else c.push.apply(c, d)
                this.sigBytes += a
                return this
            },
            clamp: function () {
                const a = this.words
                const c = this.sigBytes
                a[c >>> 2] &= 4294967295 << (32 - 8 * (c % 4))
                a.length = h.ceil(c / 4)
            },
            clone: function () {
                const a = m.clone.call(this)
                a.words = this.words.slice(0)
                return a
            },
            random: function (a) {
                for (var c = [], d = 0; d < a; d += 4) c.push((4294967296 * h.random()) | 0)
                return new r.init(c, a)
            },
        }))
        const l = (f.enc = {})
        var k = (l.Hex = {
            stringify: function (a) {
                const c = a.words
                a = a.sigBytes
                for (var d = [], b = 0; b < a; b++) {
                    const e = (c[b >>> 2] >>> (24 - 8 * (b % 4))) & 255
                    d.push((e >>> 4).toString(16))
                    d.push((e & 15).toString(16))
                }
                return d.join('')
            },
            parse: function (a) {
                for (var c = a.length, d = [], b = 0; b < c; b += 2)
                    d[b >>> 3] |= parseInt(a.substr(b, 2), 16) << (24 - 4 * (b % 8))
                return new r.init(d, c / 2)
            },
        })
        const n = (l.Latin1 = {
            stringify: function (a) {
                const c = a.words
                a = a.sigBytes
                for (var d = [], b = 0; b < a; b++)
                    d.push(String.fromCharCode((c[b >>> 2] >>> (24 - 8 * (b % 4))) & 255))
                return d.join('')
            },
            parse: function (a) {
                for (var c = a.length, d = [], b = 0; b < c; b++)
                    d[b >>> 2] |= (a.charCodeAt(b) & 255) << (24 - 8 * (b % 4))
                return new r.init(d, c)
            },
        })
        const j = (l.Utf8 = {
            stringify: function (a) {
                try {
                    return decodeURIComponent(escape(n.stringify(a)))
                } catch (c) {
                    throw Error('Malformed UTF-8 data')
                }
            },
            parse: function (a) {
                return n.parse(unescape(encodeURIComponent(a)))
            },
        })
        const u = (g.BufferedBlockAlgorithm = m.extend({
            reset: function () {
                this._data = new r.init()
                this._nDataBytes = 0
            },
            _append: function (a) {
                typeof a === 'string' && (a = j.parse(a))
                this._data.concat(a)
                this._nDataBytes += a.sigBytes
            },
            _process: function (a) {
                const c = this._data
                const d = c.words
                let b = c.sigBytes
                const e = this.blockSize
                var f = b / (4 * e)
                var f = a ? h.ceil(f) : h.max((f | 0) - this._minBufferSize, 0)
                a = f * e
                b = h.min(4 * a, b)
                if (a) {
                    for (var g = 0; g < a; g += e) this._doProcessBlock(d, g)
                    g = d.splice(0, a)
                    c.sigBytes -= b
                }
                return new r.init(g, b)
            },
            clone: function () {
                const a = m.clone.call(this)
                a._data = this._data.clone()
                return a
            },
            _minBufferSize: 0,
        }))
        g.Hasher = u.extend({
            cfg: m.extend(),
            init: function (a) {
                this.cfg = this.cfg.extend(a)
                this.reset()
            },
            reset: function () {
                u.reset.call(this)
                this._doReset()
            },
            update: function (a) {
                this._append(a)
                this._process()
                return this
            },
            finalize: function (a) {
                a && this._append(a)
                return this._doFinalize()
            },
            blockSize: 16,
            _createHelper: function (a) {
                return function (c, d) {
                    return new a.init(d).finalize(c)
                }
            },
            _createHmacHelper: function (a) {
                return function (c, d) {
                    return new t.HMAC.init(a, d).finalize(c)
                }
            },
        })
        var t = (f.algo = {})
        return f
    })(Math)
;(function (h) {
    for (
        var s = CryptoJS,
            f = s.lib,
            g = f.WordArray,
            q = f.Hasher,
            f = s.algo,
            m = [],
            r = [],
            l = function (a) {
                return (4294967296 * (a - (a | 0))) | 0
            },
            k = 2,
            n = 0;
        n < 64;

    ) {
        var j
        a: {
            j = k
            for (let u = h.sqrt(j), t = 2; t <= u; t++)
                if (!(j % t)) {
                    j = !1
                    break a
                }
            j = !0
        }
        j && (n < 8 && (m[n] = l(h.pow(k, 0.5))), (r[n] = l(h.pow(k, 1 / 3))), n++)
        k++
    }
    const a = []
    var f = (f.SHA256 = q.extend({
        _doReset: function () {
            this._hash = new g.init(m.slice(0))
        },
        _doProcessBlock: function (c, d) {
            for (
                var b = this._hash.words,
                    e = b[0],
                    f = b[1],
                    g = b[2],
                    j = b[3],
                    h = b[4],
                    m = b[5],
                    n = b[6],
                    q = b[7],
                    p = 0;
                p < 64;
                p++
            ) {
                if (p < 16) a[p] = c[d + p] | 0
                else {
                    var k = a[p - 15]
                    var l = a[p - 2]
                    a[p] =
                        (((k << 25) | (k >>> 7)) ^ ((k << 14) | (k >>> 18)) ^ (k >>> 3)) +
                        a[p - 7] +
                        (((l << 15) | (l >>> 17)) ^ ((l << 13) | (l >>> 19)) ^ (l >>> 10)) +
                        a[p - 16]
                }
                k =
                    q +
                    (((h << 26) | (h >>> 6)) ^ ((h << 21) | (h >>> 11)) ^ ((h << 7) | (h >>> 25))) +
                    ((h & m) ^ (~h & n)) +
                    r[p] +
                    a[p]
                l =
                    (((e << 30) | (e >>> 2)) ^ ((e << 19) | (e >>> 13)) ^ ((e << 10) | (e >>> 22))) +
                    ((e & f) ^ (e & g) ^ (f & g))
                q = n
                n = m
                m = h
                h = (j + k) | 0
                j = g
                g = f
                f = e
                e = (k + l) | 0
            }
            b[0] = (b[0] + e) | 0
            b[1] = (b[1] + f) | 0
            b[2] = (b[2] + g) | 0
            b[3] = (b[3] + j) | 0
            b[4] = (b[4] + h) | 0
            b[5] = (b[5] + m) | 0
            b[6] = (b[6] + n) | 0
            b[7] = (b[7] + q) | 0
        },
        _doFinalize: function () {
            const a = this._data
            const d = a.words
            const b = 8 * this._nDataBytes
            const e = 8 * a.sigBytes
            d[e >>> 5] |= 128 << (24 - (e % 32))
            d[(((e + 64) >>> 9) << 4) + 14] = h.floor(b / 4294967296)
            d[(((e + 64) >>> 9) << 4) + 15] = b
            a.sigBytes = 4 * d.length
            this._process()
            return this._hash
        },
        clone: function () {
            const a = q.clone.call(this)
            a._hash = this._hash.clone()
            return a
        },
    }))
    s.SHA256 = q._createHelper(f)
    s.HmacSHA256 = q._createHmacHelper(f)
})(Math)
;(function () {
    const h = CryptoJS
    const s = h.enc.Utf8
    h.algo.HMAC = h.lib.Base.extend({
        init: function (f, g) {
            f = this._hasher = new f.init()
            typeof g === 'string' && (g = s.parse(g))
            const h = f.blockSize
            const m = 4 * h
            g.sigBytes > m && (g = f.finalize(g))
            g.clamp()
            for (
                var r = (this._oKey = g.clone()),
                    l = (this._iKey = g.clone()),
                    k = r.words,
                    n = l.words,
                    j = 0;
                j < h;
                j++
            )
                (k[j] ^= 1549556828), (n[j] ^= 909522486)
            r.sigBytes = l.sigBytes = m
            this.reset()
        },
        reset: function () {
            const f = this._hasher
            f.reset()
            f.update(this._iKey)
        },
        update: function (f) {
            this._hasher.update(f)
            return this
        },
        finalize: function (f) {
            const g = this._hasher
            f = g.finalize(f)
            g.reset()
            return g.finalize(this._oKey.clone().concat(f))
        },
    })
})()

export default CryptoJS
